fix(mock): stop leaking sibling variants into allOf-inherited mocks - #3431

Closes #2155

Closes the second half of #2155, the part PR #3429 deliberately left out. When a derived schema is shaped as

Item1:
  allOf:
    - $ref: '#/components/schemas/DiscriminatorParent'
    - type: object
      properties:
        property1: { type: string }

and the parent declares both discriminator: { mapping } and oneOf, resolveMockValue was re-expanding the parent's oneOf while building Item1's allOf-chain mock body. That inlined sibling factory calls into the derived variant's mock, so the produced object had shapes belonging to other variants:

// Before — Item1's mock contained Item2/Item3 calls and Item3 had a `{ undefined }` artifact:
export const getGetTestResponseItem3Mock = (overrideResponse = {}) => ({
  ...{...{...{ undefined },                                  // ← from oneOf collapsing
                                                              //   to undefined inside the allOf chain
    ...{ property3: faker.helpers.arrayElement([...]) },
  }, type: faker.helpers.arrayElement(['item3'] as const)},
  ...overrideResponse,
});
export const getGetTestResponseItem2Mock = (overrideResponse = {}) => ({
  ...{...{...faker.helpers.arrayElement([{ ...getGetTestResponseItem3Mock() }]),
  ...},
  ...overrideResponse,
});
export const getGetTestResponseItem1Mock = (overrideResponse = {}) => ({
  ...{...{...faker.helpers.arrayElement([
    { ...getGetTestResponseItem2Mock() },                    // ← Item1 carries Item2's shape
    { ...getGetTestResponseItem3Mock() },                    //   and Item3's shape
  ]), ...},
  ...overrideResponse,
});

// After — each variant only describes its own properties + constrained discriminator:
export const getGetTestResponseItem1Mock = (overrideResponse = {}) => ({
  ...{...{...{ property1: faker.helpers.arrayElement([...]) }},
    type: faker.helpers.arrayElement(['item1'] as const),
  },
  ...overrideResponse,
});
// (Item2/Item3 follow the same clean shape.)

Fix

In resolveMockValue, after loading a $ref whose schema has both discriminator and oneOf, check whether the resolution stack is currently inside one of that parent's mapping targets. If so, we are by construction expanding a specific variant of the union — the parent's oneOf is descriptive, not additive — so:

1. Drop oneOf from a local copy of the parent before passing to getMockScalar (prevents sibling-factory inlining).
2. Symmetrically with fix(mock): preserve discriminator value when oneOf parent declares the same property #3429's oneOf-side fix, also drop the discriminator key from the parent's properties (and required). Each variant already carries a constrained discriminator value via resolveDiscriminators, so the parent's free-choice enum would otherwise become dead code shadowed by the variant's constrained value through spread merge.

if (
  combine?.separator === 'allOf' &&
  newSchema.discriminator &&
  newSchema.oneOf
) {
  const mappingTargetNames = Object.values(parentDiscriminator.mapping ?? {})
    .map(ref => pascal(ref.split('/').pop() ?? ''));
  const expandingAsVariant = existingReferencedProperties
    .some(refName => mappingTargetNames.includes(refName));

  if (expandingAsVariant) {
    delete (newSchema as Record<string, unknown>).oneOf;
    // ...also strip propertyName from properties + required
  }
}

Why the mapping-target guard matters

The naive form ("schema has discriminator + oneOf and we're inside allOf → strip oneOf") breaks cases where a discriminator parent is referenced via allOf but the surrounding schema is not a variant. Concrete example from this repo's tests/specifications/one-of-nested.yaml:

Example2:
  type: object
  properties:
    kind: { type: string, enum: [example2] }
    expiry:
      allOf:
        - $ref: '#/components/schemas/PointInFuture'   # PointInFuture is the discriminator parent

Example2.expiry is a field holding a PointInFuture value. The mock for expiry must still randomize across PointInFutureAbsolute / PointInFutureRelative. Without the mapping-target check, the naive fix would emit an empty expiry. The check fixes this — Example2 is not in PointInFuture.discriminator.mapping, so the strip does not apply and the snapshot for that fixture is unchanged.

Tests

• New fixture: tests/specifications/discriminator-oneof-allof.yaml (the issue's exact reproduction shape).
• New mock config + snapshot under tests/__snapshots__/mock/discriminator-oneof-allof/.
• Focused regression in tests/api-generation.spec.ts that asserts each per-variant factory body does not reference its siblings' factories — a more precise signal than the full-file snapshot diff alone.
• Existing discriminator fixtures (discriminator-oneof-union from fix(mock): preserve discriminator value when oneOf parent declares the same property #3429, recursive-discriminator-allof, one-of-nested, polymorphic, boolean-discriminator, lowercase-discriminator) generate identically — verified locally with no snapshot diffs.

Type-generation circularity (orthogonal)

The model files generated from this fixture trip a separate, pre-existing core type-generation circularity:

generated/mock/discriminator-oneof-allof/model/item1.ts(10,13):
  error TS2456: Type alias 'Item1' circularly references itself.

Item1 is emitted as Omit<DiscriminatorTest, 'type'> & { type: Item1Type, property1?: string } while DiscriminatorTest = Item1 | Item2 | Item3, which is a TS type-alias cycle. This is unrelated to the mock generator — the same fixture exhibits the issue with or without this PR — and tackling it cleanly belongs in @orval/core's getCombineSchema / discriminator paths.

To keep the mock regression testable today, the new fixture is added to the tests/scripts/typecheck-generated.mjs exclusion list (alongside the existing MCP exclusion). Follow-up issue filed for the core type-circularity so it's not lost: #3432.

Summary by CodeRabbit

• Bug Fixes

  • Fixed mock generation for discriminated union types with allOf-inherited variants to avoid duplicated union/discriminator behavior in generated responses.

• Tests

  • Added regression test ensuring inherited-variant mocks do not reference sibling factories.
  • Added generated mock snapshots and model types for the discriminator/oneOf/allOf scenario.

• Chores

  • Added OpenAPI test spec, Orval mock config entry, and updated typecheck script exclusions.